{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# FSRS4Anki Optimizer mini-batch_initial-stability_filter-data-LOF"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[![open in colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/open-spaced-repetition/fsrs4anki/blob/main/archive/experiment/mini-batch_initial-stability_LOF.ipynb)\n",
    "\n",
    "↑ Click the above button to open the optimizer on Google Colab.\n",
    "\n",
    "> If you can't see the button and are located in the Chinese Mainland, please use a proxy or VPN."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Upload your **Anki Deck Package (.apkg)** file or **Anki Collection Package (.colpkg)** file on the `Left sidebar -> Files`, drag and drop your file in the current directory (not the `sample_data` directory). \n",
    "\n",
    "No need to include media. Need to include scheduling information. \n",
    "\n",
    "> If you use the latest version of Anki, please check the box `Support older Anki versions (slower/larger files)` when you export.\n",
    "\n",
    "You can export it via `File -> Export...` or `Ctrl + E` in the main window of Anki.\n",
    "\n",
    "Then replace the `filename` with yours in the next code cell. And set the `timezone` and `next_day_starts_at` which can be found in your preferences of Anki.\n",
    "\n",
    "After that, just run all (`Runtime -> Run all` or `Ctrl + F9`) and wait for minutes. You can see the optimal parameters in section **2.3 Result**. Copy them, replace the parameters in `fsrs4anki_scheduler.js`, and paste them into the custom scheduling of your deck options (require Anki version >= 2.1.55).\n",
    "\n",
    "**NOTE**: The default output is generated from my review logs. If you find the output is the same as mine, maybe your notebook hasn't run there.\n",
    "\n",
    "**Contribute to SRS Research**: If you want to share your data with me, please fill this form: https://forms.gle/KaojsBbhMCytaA7h8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here are some settings that you need to replace before running this optimizer.\n",
    "\n",
    "filename = \"./Main__English__Hard English_27.04.2023.apkg\"\n",
    "# If you upload deck file, replace it with your deck filename. E.g., ALL__Learning.apkg\n",
    "# If you upload collection file, replace it with your colpgk filename. E.g., collection-2022-09-18@13-21-58.colpkg\n",
    "\n",
    "# Replace it with your timezone. I'm in China, so I use Asia/Shanghai.\n",
    "# You can find your timezone here: https://gist.github.com/heyalexej/8bf688fd67d7199be4a1682b3eec7568\n",
    "timezone = 'Europe/Moscow'\n",
    "\n",
    "# Replace it with your Anki's setting in Preferences -> Scheduling.\n",
    "next_day_starts_at = 5\n",
    "\n",
    "# Replace it if you don't want the optimizer to use the review logs before a specific date.\n",
    "revlog_start_date = \"2006-10-05\""
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1 Build dataset"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.1 Extract Anki collection & deck file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Extract successfully!\n"
     ]
    }
   ],
   "source": [
    "import zipfile\n",
    "import sqlite3\n",
    "import time\n",
    "from tqdm import notebook\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import os\n",
    "from datetime import timedelta, datetime\n",
    "import matplotlib.pyplot as plt\n",
    "import math\n",
    "import sys\n",
    "import torch\n",
    "from torch import nn\n",
    "from sklearn.utils import shuffle\n",
    "# Extract the collection file or deck file to get the .anki21 database.\n",
    "with zipfile.ZipFile(f'./{filename}', 'r') as zip_ref:\n",
    "    zip_ref.extractall('./')\n",
    "    print(\"Extract successfully!\")\n",
    "\n",
    "\n",
    "notebook.tqdm.pandas()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 1.2 Create time-series feature & analysis\n",
    "\n",
    "The following code cell will extract the review logs from your Anki collection and preprocess them to a trainset which is saved in [./revlog_history.tsv](./revlog_history.tsv).\n",
    "\n",
    "The time-series features are important in optimizing the model's parameters. For more detail, please see my paper: https://www.maimemo.com/paper/\n",
    "\n",
    "Then it will generate a concise analysis for your review logs. \n",
    "\n",
    "- The `r_history` is the history of ratings on each review. `3,3,3,1` means that you press `Good, Good, Good, Again`. It only contains the first rating for each card on the review date, i.e., when you press `Again` in review and  `Good` in relearning steps 10min later, only `Again` will be recorded.\n",
    "- The `avg_interval` is the actual average interval after you rate your cards as the `r_history`. It could be longer than the interval given by Anki's built-in scheduler because you reviewed some overdue cards.\n",
    "- The `avg_retention` is the average retention after you press as the `r_history`. `Again` counts as failed recall, and `Hard, Good and Easy` count as successful recall. Retention is the percentage of your successful recall.\n",
    "- The `stability` is the estimated memory state variable, which is an approximate interval that leads to 90% retention.\n",
    "- The `factor` is `stability / previous stability`.\n",
    "- The `group_cnt` is the number of review logs that have the same `r_history`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "revlog.csv saved.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9d1b4d52155e4fd59d13f65d31082ba9",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/6042 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a16ade27b7124df2865613e77958f34c",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/24011 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(48083, 17)\n",
      "(46926, 16)\n",
      "(42909, 16)\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2c55efd0a2e474e9023e18dfa9de4de",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/5967 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(29436, 16)\n",
      "Trainset saved.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a2c5c177a6264a6480ba9dc5841b33b7",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/9457 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Retention calculated.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9723fde077424a12a130b049d5571051",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/4909 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Stability calculated.\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "867c4efc7a2e4729b299893cff98c612",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/200 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:again, 2:hard, 3:good, 4:easy\n",
      "\n",
      "r_history  avg_interval  avg_retention  stability  factor  group_cnt\n",
      "        2           1.1          0.580        0.2     inf       1390\n",
      "      2,3           1.1          0.960        2.9   14.50        423\n",
      "    2,3,3           4.6          0.980       24.4    8.41        273\n",
      "  2,3,3,3          20.4          0.848       11.5    0.47        212\n",
      "2,3,3,3,3          73.2          0.836       23.5    2.04         73\n",
      "        3           1.1          0.837        0.7     inf       2833\n",
      "      3,3           5.8          0.961       15.0   21.43       1680\n",
      "    3,3,3          18.1          0.970       48.4    3.23       1056\n",
      "  3,3,3,3          69.5          0.933       99.1    2.05        619\n",
      "3,3,3,3,3         153.0          0.863      105.5    1.06        133\n",
      "        4          12.0          0.980       79.1     inf       1382\n",
      "      4,3          40.0          0.981      186.1    2.35        416\n",
      "    4,3,3          45.4          0.984      297.2    1.60        113\n",
      "  4,3,3,3          76.9          0.990     1100.5    3.70         50\n",
      "Analysis saved!\n"
     ]
    }
   ],
   "source": [
    "if os.path.isfile(\"collection.anki21b\"):\n",
    "    os.remove(\"collection.anki21b\")\n",
    "    raise Exception(\n",
    "        \"Please export the file with `support older Anki versions` if you use the latest version of Anki.\")\n",
    "elif os.path.isfile(\"collection.anki21\"):\n",
    "    con = sqlite3.connect(\"collection.anki21\")\n",
    "elif os.path.isfile(\"collection.anki2\"):\n",
    "    con = sqlite3.connect(\"collection.anki2\")\n",
    "else:\n",
    "    raise Exception(\"Collection not exist!\")\n",
    "cur = con.cursor()\n",
    "res = cur.execute(\"SELECT * FROM revlog\")\n",
    "revlog = res.fetchall()\n",
    "\n",
    "df = pd.DataFrame(revlog)\n",
    "df.columns = ['id', 'cid', 'usn', 'r', 'ivl',\n",
    "              'last_ivl', 'factor', 'time', 'type']\n",
    "df = df[(df['cid'] <= time.time() * 1000) &\n",
    "        (df['id'] <= time.time() * 1000) &\n",
    "        (df['r'] > 0)].copy()\n",
    "df['create_date'] = pd.to_datetime(df['cid'] // 1000, unit='s')\n",
    "df['create_date'] = df['create_date'].dt.tz_localize(\n",
    "    'UTC').dt.tz_convert(timezone)\n",
    "df['review_date'] = pd.to_datetime(df['id'] // 1000, unit='s')\n",
    "df['review_date'] = df['review_date'].dt.tz_localize(\n",
    "    'UTC').dt.tz_convert(timezone)\n",
    "df.drop(df[df['review_date'].dt.year < 2006].index, inplace=True)\n",
    "df.sort_values(by=['cid', 'id'], inplace=True, ignore_index=True)\n",
    "type_sequence = np.array(df['type'])\n",
    "time_sequence = np.array(df['time'])\n",
    "df.to_csv(\"revlog.csv\", index=False)\n",
    "print(\"revlog.csv saved.\")\n",
    "df = df[df['type'] != 3].copy()\n",
    "df['real_days'] = df['review_date'] - timedelta(hours=next_day_starts_at)\n",
    "df['real_days'] = pd.DatetimeIndex(df['real_days'].dt.floor('D', ambiguous='infer', nonexistent='shift_forward')).to_julian_date()\n",
    "\n",
    "# Remove `again` in `relearning` stage.\n",
    "df = df.drop(df[(df['type'] == 2) & (df['r'] == 1)].index)\n",
    "# Keep `easy` as the first rating when `easy` is in `learning` stage.\n",
    "cid_with_r_4 = df[(df['type'] == 0) & (df['r'] == 4)]['cid'].unique()\n",
    "df1 = df[(df['cid'].isin(cid_with_r_4)) & (df['type'] == 0) & (df['r'] == 4)]\n",
    "df2 = df[~((df['cid'].isin(cid_with_r_4)) & (df['type'] == 0) & (df['r'] != 4))]\n",
    "df = pd.concat([df1, df2])\n",
    "\n",
    "\n",
    "df.drop_duplicates(['cid', 'real_days'], keep='first', inplace=True)\n",
    "df.sort_values(by=['cid', 'id'], inplace=True, ignore_index=True)\n",
    "df['delta_t'] = df.real_days.diff()\n",
    "df.dropna(inplace=True)\n",
    "df['delta_t'] = df['delta_t'].astype(dtype=int)\n",
    "df['i'] = 1\n",
    "df['r_history'] = \"\"\n",
    "df['t_history'] = \"\"\n",
    "col_idx = {key: i for i, key in enumerate(df.columns)}\n",
    "\n",
    "\n",
    "# code from https://github.com/L-M-Sherlock/anki_revlog_analysis/blob/main/revlog_analysis.py\n",
    "def get_feature(x):\n",
    "    last_kind = None\n",
    "    for idx, log in enumerate(x.itertuples()):\n",
    "        if last_kind is not None and last_kind in (1, 2) and log.type == 0:\n",
    "            return x.iloc[:idx]\n",
    "        last_kind = log.type\n",
    "        if idx == 0:\n",
    "            if log.type != 0:\n",
    "                return x.iloc[:idx]\n",
    "            x.iloc[idx, col_idx['delta_t']] = 0\n",
    "        if idx == x.shape[0] - 1:\n",
    "            break\n",
    "        x.iloc[idx + 1, col_idx['i']] = x.iloc[idx, col_idx['i']] + 1\n",
    "        x.iloc[idx + 1, col_idx['t_history']] = f\"{x.iloc[idx, col_idx['t_history']]},{x.iloc[idx, col_idx['delta_t']]}\"\n",
    "        x.iloc[idx + 1, col_idx['r_history']] = f\"{x.iloc[idx, col_idx['r_history']]},{x.iloc[idx, col_idx['r']]}\"\n",
    "    return x\n",
    "\n",
    "df = df.groupby('cid', as_index=False, group_keys=False).progress_apply(get_feature)\n",
    "\n",
    "from sklearn.neighbors import LocalOutlierFactor\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\", category=UserWarning)\n",
    "clf = LocalOutlierFactor()\n",
    "\n",
    "def remove_outliers(sub_df):\n",
    "    if sub_df.shape[0] < 3:\n",
    "        return sub_df\n",
    "    sub_df['outlier'] = clf.fit_predict(sub_df[['delta_t']])\n",
    "    return sub_df\n",
    "\n",
    "\n",
    "df = df.groupby(['r_history', 't_history'], as_index=False, group_keys=False).progress_apply(remove_outliers)\n",
    "print(df.shape)\n",
    "df.to_csv(\"revlog_history_with_outliers.tsv\", sep=\"\\t\", index=False)\n",
    "df = df[df['outlier'] != -1]\n",
    "df.drop(columns=['outlier'], inplace=True)\n",
    "print(df.shape)\n",
    "\n",
    "# Remove super-overdue reviews.\n",
    "df['last_ivl'] = df['last_ivl'].map(lambda x: max(1, -x/86400) if x < 0 else x)\n",
    "df['overdue_rate'] = df['delta_t'] / df['last_ivl']\n",
    "df = df[df['overdue_rate'] < 4]\n",
    "del df['overdue_rate']\n",
    "print(df.shape)\n",
    "\n",
    "def remove_non_continuous_rows(group):\n",
    "    discontinuity = group['i'].diff().fillna(1).ne(1)\n",
    "    if not discontinuity.any():\n",
    "        return group\n",
    "    else:\n",
    "        first_non_continuous_index = discontinuity.idxmax()\n",
    "        return group.loc[:first_non_continuous_index-1]\n",
    "\n",
    "df = df.groupby('cid', as_index=False, group_keys=False).progress_apply(remove_non_continuous_rows)\n",
    "df.to_csv(\"revlog_history_with_outliers_and_discontinuity.tsv\", sep=\"\\t\", index=False)\n",
    "print(df.shape)\n",
    "\n",
    "df = df[df['id'] >= time.mktime(datetime.strptime(revlog_start_date, \"%Y-%m-%d\").timetuple()) * 1000]\n",
    "df[\"t_history\"] = df[\"t_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
    "df[\"r_history\"] = df[\"r_history\"].map(lambda x: x[1:] if len(x) > 1 else x)\n",
    "df.to_csv('revlog_history.tsv', sep=\"\\t\", index=False)\n",
    "print(\"Trainset saved.\")\n",
    "\n",
    "def cal_retention(group: pd.DataFrame) -> pd.DataFrame:\n",
    "    group['retention'] = round(group['r'].map(lambda x: {1: 0, 2: 1, 3: 1, 4: 1}[x]).mean(), 4)\n",
    "    group['total_cnt'] = group.shape[0]\n",
    "    return group\n",
    "\n",
    "df = df.groupby(by=['r_history', 'delta_t'], group_keys=False).progress_apply(cal_retention)\n",
    "print(\"Retention calculated.\")\n",
    "df = df.drop(columns=['id', 'cid', 'usn', 'ivl', 'last_ivl', 'factor', 'time', 'type', 'create_date', 'review_date', 'real_days', 'r', 't_history'])\n",
    "df.drop_duplicates(inplace=True)\n",
    "df['retention'] = df['retention'].map(lambda x: max(min(0.99, x), 0.01))\n",
    "\n",
    "def cal_stability(group: pd.DataFrame) -> pd.DataFrame:\n",
    "    group_cnt = sum(group['total_cnt'])\n",
    "    if group_cnt < 10:\n",
    "        return pd.DataFrame()\n",
    "    group['group_cnt'] = group_cnt\n",
    "    if group['i'].values[0] > 1:\n",
    "        r_ivl_cnt = sum(group['delta_t'] * group['retention'].map(np.log) * pow(group['total_cnt'], 2))\n",
    "        ivl_ivl_cnt = sum(group['delta_t'].map(lambda x: x ** 2) * pow(group['total_cnt'], 2))\n",
    "        group['stability'] = round(np.log(0.9) / (r_ivl_cnt / ivl_ivl_cnt), 1)\n",
    "    else:\n",
    "        group['stability'] = 0.0\n",
    "    group['avg_retention'] = round(sum(group['retention'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 3)\n",
    "    group['avg_interval'] = round(sum(group['delta_t'] * pow(group['total_cnt'], 2)) / sum(pow(group['total_cnt'], 2)), 1)\n",
    "    del group['total_cnt']\n",
    "    del group['retention']\n",
    "    del group['delta_t']\n",
    "    return group\n",
    "\n",
    "df = df.groupby(by=['r_history'], group_keys=False).progress_apply(cal_stability)\n",
    "print(\"Stability calculated.\")\n",
    "df.reset_index(drop = True, inplace = True)\n",
    "df.drop_duplicates(inplace=True)\n",
    "df.sort_values(by=['r_history'], inplace=True, ignore_index=True)\n",
    "\n",
    "if df.shape[0] > 0:\n",
    "    for idx in notebook.tqdm(df.index):\n",
    "        item = df.loc[idx]\n",
    "        index = df[(df['i'] == item['i'] + 1) & (df['r_history'].str.startswith(item['r_history']))].index\n",
    "        df.loc[index, 'last_stability'] = item['stability']\n",
    "    df['factor'] = round(df['stability'] / df['last_stability'], 2)\n",
    "    df = df[(df['i'] >= 2) & (df['group_cnt'] >= 50)]\n",
    "    df['last_recall'] = df['r_history'].map(lambda x: x[-1])\n",
    "    df = df[df.groupby(['i', 'r_history'], group_keys=False)['group_cnt'].transform(max) == df['group_cnt']]\n",
    "    df.to_csv('./stability_for_analysis.tsv', sep='\\t', index=None)\n",
    "    print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
    "    print(df[df['r_history'].str.contains(r'^[1-4][^124]*$', regex=True)][['r_history', 'avg_interval', 'avg_retention', 'stability', 'factor', 'group_cnt']].to_string(index=False))\n",
    "    print(\"Analysis saved!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2 Optimize parameter"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.1 Define the model\n",
    "\n",
    "FSRS is a time-series model for predicting memory states."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "init_w = [0, 1, 5, 0.5, 0.5, 0.2, 1.4, 0.12, 0.8, 2, 0.2, 0.2, 1, 0, 0.5, 1, 2]\n",
    "'''\n",
    "w[0]: initial_stability_for_again_answer\n",
    "w[1]: initial_stability_step_per_rating\n",
    "w[2]: initial_difficulty_for_good_answer\n",
    "w[3]: initial_difficulty_step_per_rating\n",
    "w[4]: next_difficulty_step_per_rating\n",
    "w[5]: next_difficulty_reversion_to_mean_speed (used to avoid ease hell)\n",
    "w[6]: next_stability_factor_after_success\n",
    "w[7]: next_stability_stabilization_decay_after_success\n",
    "w[8]: next_stability_retrievability_gain_after_success\n",
    "w[9]: next_stability_factor_after_failure\n",
    "w[10]: next_stability_difficulty_decay_after_success\n",
    "w[11]: next_stability_stability_gain_after_failure\n",
    "w[12]: next_stability_retrievability_gain_after_failure\n",
    "For more details about the parameters, please see: \n",
    "https://github.com/open-spaced-repetition/fsrs4anki/wiki/Free-Spaced-Repetition-Scheduler\n",
    "'''\n",
    "\n",
    "\n",
    "class FSRS(nn.Module):\n",
    "    def __init__(self, w):\n",
    "        super(FSRS, self).__init__()\n",
    "        self.w = nn.Parameter(torch.tensor(w, dtype=torch.float32))\n",
    "\n",
    "    def stability_after_success(self, state, new_d, r):\n",
    "        new_s = state[:,0] * (1 + torch.exp(self.w[6]) *\n",
    "                        (11 - new_d) *\n",
    "                        torch.pow(state[:,0], -self.w[7]) *\n",
    "                        (torch.exp((1 - r) * self.w[8]) - 1))\n",
    "        return new_s\n",
    "    \n",
    "    def stability_after_failure(self, state, new_d, r):\n",
    "        new_s = self.w[9] * torch.pow(new_d, -self.w[10]) * torch.pow(\n",
    "            state[:,0], self.w[11]) * torch.exp((1 - r) * self.w[12])\n",
    "        return new_s\n",
    "\n",
    "    def step(self, X, state):\n",
    "        '''\n",
    "        :param X: shape[batch_size, 2], X[:,0] is elapsed time, X[:,1] is rating\n",
    "        :param state: shape[batch_size, 2], state[:,0] is stability, state[:,1] is difficulty\n",
    "        :return state:\n",
    "        '''\n",
    "        keys = torch.tensor([1, 2, 3, 4])\n",
    "        keys = keys.view(1, -1).expand(X[:,1].long().size(0), -1)\n",
    "        index = (X[:,1].long().unsqueeze(1) == keys).nonzero(as_tuple=True)\n",
    "        if torch.equal(state, torch.zeros_like(state)):\n",
    "            # first learn, init memory states\n",
    "            new_s = torch.exp(self.w[13+index[1]])\n",
    "            new_d = self.w[2] - self.w[3] * (X[:,1] - 3)\n",
    "            new_d = new_d.clamp(1, 10)\n",
    "        else:\n",
    "            r = torch.exp(np.log(0.9) * X[:,0] / state[:,0])\n",
    "            new_d = state[:,1] - self.w[4] * (X[:,1] - 3)\n",
    "            new_d = self.mean_reversion(self.w[2], new_d)\n",
    "            new_d = new_d.clamp(1, 10)\n",
    "            condition = X[:,1] > 1\n",
    "            new_s = torch.where(condition, self.stability_after_success(state, new_d, r), self.stability_after_failure(state, new_d, r))\n",
    "        return torch.stack([new_s, new_d], dim=1)\n",
    "\n",
    "    def forward(self, inputs, state=None):\n",
    "        '''\n",
    "        :param inputs: shape[seq_len, batch_size, 2]\n",
    "        '''\n",
    "        if state is None:\n",
    "            state = torch.zeros((inputs.shape[1], 2))\n",
    "        else:\n",
    "            state, = state\n",
    "        outputs = []\n",
    "        for X in inputs:\n",
    "            state = self.step(X, state)\n",
    "            outputs.append(state)\n",
    "        return torch.stack(outputs), state\n",
    "\n",
    "    def mean_reversion(self, init, current):\n",
    "        return self.w[5] * init + (1-self.w[5]) * current\n",
    "\n",
    "\n",
    "class WeightClipper(object):\n",
    "    def __init__(self, frequency=1):\n",
    "        self.frequency = frequency\n",
    "\n",
    "    def __call__(self, module):\n",
    "        if hasattr(module, 'w'):\n",
    "            w = module.w.data\n",
    "            w[2] = w[2].clamp(1, 10)\n",
    "            w[3] = w[3].clamp(0.1, 5)\n",
    "            w[4] = w[4].clamp(0.1, 5)\n",
    "            w[5] = w[5].clamp(0, 0.5)\n",
    "            w[6] = w[6].clamp(0, 2)\n",
    "            w[7] = w[7].clamp(0.01, 0.8)\n",
    "            w[8] = w[8].clamp(0.01, 1.5)\n",
    "            w[9] = w[9].clamp(0.5, 5)\n",
    "            w[10] = w[10].clamp(0.01, 2)\n",
    "            w[11] = w[11].clamp(0.01, 0.9)\n",
    "            w[12] = w[12].clamp(0.01, 4)\n",
    "            module.w.data = w\n",
    "\n",
    "def lineToTensor(line):\n",
    "    ivl = line[0].split(',')\n",
    "    response = line[1].split(',')\n",
    "    tensor = torch.zeros(len(response), 2)\n",
    "    for li, response in enumerate(response):\n",
    "        tensor[li][0] = int(ivl[li])\n",
    "        tensor[li][1] = int(response)\n",
    "    return tensor\n",
    "\n",
    "from torch.utils.data import Dataset, DataLoader, Sampler\n",
    "from torch.nn.utils.rnn import pad_sequence, pack_padded_sequence, pad_packed_sequence\n",
    "from typing import List\n",
    "\n",
    "class RevlogDataset(Dataset):\n",
    "    def __init__(self, dataframe):\n",
    "        padded = pad_sequence(dataframe['tensor'].to_list(), batch_first=True, padding_value=0)\n",
    "        self.x_train = padded.int()\n",
    "        self.t_train = torch.tensor(dataframe['delta_t'].values, dtype=torch.int)\n",
    "        self.y_train = torch.tensor(dataframe['y'].values, dtype=torch.float)\n",
    "        self.seq_len = torch.tensor(dataframe['tensor'].map(len).values, dtype=torch.long)\n",
    "\n",
    "    def __getitem__(self, idx):\n",
    "        return self.x_train[idx], self.t_train[idx], self.y_train[idx], self.seq_len[idx]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.y_train)\n",
    "    \n",
    "class RevlogSampler(Sampler[List[int]]):\n",
    "    def __init__(self, data_source, batch_size):\n",
    "        self.data_source = data_source\n",
    "        self.batch_size = batch_size\n",
    "        lengths = np.array(data_source.seq_len)\n",
    "        indices = np.argsort(lengths)\n",
    "        full_batches, remainder = divmod(indices.size, self.batch_size)\n",
    "        if full_batches > 0:\n",
    "            self.batch_indices = np.split(indices[:-remainder], full_batches)\n",
    "        else:\n",
    "            self.batch_indices = []\n",
    "        if remainder:\n",
    "            self.batch_indices.append(indices[-remainder:])\n",
    "        self.batch_nums = len(self.batch_indices)\n",
    "        # seed = int(torch.empty((), dtype=torch.int64).random_().item())\n",
    "        seed = 2023\n",
    "        self.generator = torch.Generator()\n",
    "        self.generator.manual_seed(seed)\n",
    "\n",
    "    def __iter__(self):\n",
    "        yield from [self.batch_indices[idx] for idx in torch.randperm(self.batch_nums, generator=self.generator).tolist()]\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.data_source)\n",
    "\n",
    "\n",
    "def collate_fn(batch):\n",
    "    sequences, delta_ts, labels, seq_lens = zip(*batch)\n",
    "    sequences_packed = pack_padded_sequence(torch.stack(sequences, dim=1), lengths=torch.stack(seq_lens), batch_first=False, enforce_sorted=False)\n",
    "    sequences_padded, length = pad_packed_sequence(sequences_packed, batch_first=False)\n",
    "    sequences_padded = torch.as_tensor(sequences_padded)\n",
    "    seq_lens = torch.as_tensor(length)\n",
    "    delta_ts = torch.as_tensor(delta_ts)\n",
    "    labels = torch.as_tensor(labels)\n",
    "    return sequences_padded, delta_ts, labels, seq_lens\n",
    "\n",
    "class Optimizer(object):\n",
    "    def __init__(self, train_set, test_set, n_epoch=1, lr=1e-2, batch_size=256) -> None:\n",
    "        self.model = FSRS(init_w)\n",
    "        self.optimizer = torch.optim.Adam(self.model.parameters(), lr=lr)\n",
    "        self.clipper = WeightClipper()\n",
    "        self.batch_size = batch_size\n",
    "        self.build_dataset(train_set, test_set)\n",
    "        self.n_epoch = n_epoch\n",
    "        self.batch_nums = self.next_train_data_loader.batch_sampler.batch_nums\n",
    "        self.scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(self.optimizer, T_max=self.batch_nums * n_epoch)\n",
    "        self.avg_train_losses = []\n",
    "        self.avg_eval_losses = []\n",
    "        self.loss_fn = nn.BCELoss(reduction='sum')\n",
    "\n",
    "    def build_dataset(self, train_set, test_set):\n",
    "        pre_train_set = train_set[train_set['i'] == 2]\n",
    "        self.pre_train_set = RevlogDataset(pre_train_set)\n",
    "        sampler = RevlogSampler(self.pre_train_set, batch_size=self.batch_size)\n",
    "        self.pre_train_data_loader = DataLoader(self.pre_train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        next_train_set = train_set[train_set['i'] > 2]\n",
    "        self.next_train_set = RevlogDataset(next_train_set)\n",
    "        sampler = RevlogSampler(self.next_train_set, batch_size=self.batch_size)\n",
    "        self.next_train_data_loader = DataLoader(self.next_train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        self.train_set = RevlogDataset(train_set)\n",
    "        sampler = RevlogSampler(self.train_set, batch_size=self.batch_size)\n",
    "        self.train_data_loader = DataLoader(self.train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "\n",
    "        self.test_set = RevlogDataset(test_set)\n",
    "        sampler = RevlogSampler(self.test_set, batch_size=self.batch_size)\n",
    "        self.test_data_loader = DataLoader(self.test_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "        print(\"dataset built\")\n",
    "\n",
    "    def train(self):\n",
    "        # pretrain\n",
    "        self.eval()\n",
    "        pbar = notebook.tqdm(desc=\"pre-train\", colour=\"red\", total=len(self.pre_train_data_loader) * self.n_epoch * 10)\n",
    "\n",
    "        for k in range(self.n_epoch * 10):\n",
    "            for i, batch in enumerate(self.pre_train_data_loader):\n",
    "                self.model.train()\n",
    "                self.optimizer.zero_grad()\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss = self.loss_fn(retentions, labels)\n",
    "                loss.backward()\n",
    "                self.optimizer.step()\n",
    "                self.model.apply(self.clipper)\n",
    "                pbar.update(n=real_batch_size)\n",
    "\n",
    "        pbar.close()\n",
    "        for name, param in self.model.named_parameters():\n",
    "            print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
    "\n",
    "        epoch_len = len(self.next_train_data_loader)\n",
    "        pbar = notebook.tqdm(desc=\"train\", colour=\"red\", total=epoch_len*self.n_epoch)\n",
    "        print_len = max(self.batch_nums*self.n_epoch // 10, 1)\n",
    "\n",
    "\n",
    "        for k in range(self.n_epoch):\n",
    "            self.eval()\n",
    "            for i, batch in enumerate(self.next_train_data_loader):\n",
    "                self.model.train()\n",
    "                self.optimizer.zero_grad()\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss = self.loss_fn(retentions, labels)\n",
    "                loss.backward()\n",
    "                for param in self.model.parameters():\n",
    "                    param.grad[:2] = torch.zeros(2)\n",
    "                    param.grad[13:17] = torch.zeros(4)\n",
    "                self.optimizer.step()\n",
    "                self.scheduler.step()\n",
    "                self.model.apply(self.clipper)\n",
    "                pbar.update(real_batch_size)\n",
    "\n",
    "                if (k * self.batch_nums + i + 1) % print_len == 0:\n",
    "                    print(f\"iteration: {k * epoch_len + (i + 1) * self.batch_size}\")\n",
    "                    for name, param in self.model.named_parameters():\n",
    "                        print(f\"{name}: {list(map(lambda x: round(float(x), 4),param))}\")\n",
    "        pbar.close()\n",
    "                \n",
    "        self.eval()\n",
    "\n",
    "        w = list(map(lambda x: round(float(x), 4), dict(self.model.named_parameters())['w'].data))\n",
    "        return w\n",
    "\n",
    "    def eval(self):\n",
    "        self.model.eval()\n",
    "        with torch.no_grad():\n",
    "            sampler = RevlogSampler(self.train_set, batch_size=4096)\n",
    "            train_data_loader = DataLoader(self.train_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "            loss = 0\n",
    "            for batch in train_data_loader:\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss += self.loss_fn(retentions, labels)\n",
    "            self.avg_train_losses.append(loss/len(train_data_loader))\n",
    "            print(f\"Loss in trainset: {self.avg_train_losses[-1]:.4f}\")\n",
    "\n",
    "            sampler = RevlogSampler(self.test_set, batch_size=4096)\n",
    "            test_data_loader = DataLoader(self.test_set, batch_sampler=sampler, collate_fn=collate_fn)\n",
    "            loss = 0\n",
    "            for batch in test_data_loader:\n",
    "                sequences, delta_ts, labels, seq_lens = batch\n",
    "                real_batch_size = seq_lens.shape[0]\n",
    "                outputs, _ = self.model(sequences)\n",
    "                stabilities = outputs[seq_lens-1, torch.arange(real_batch_size), 0]\n",
    "                retentions = torch.exp(np.log(0.9) * delta_ts / stabilities)\n",
    "                loss += self.loss_fn(retentions, labels)\n",
    "            self.avg_eval_losses.append(loss/len(test_data_loader))\n",
    "            print(f\"Loss in testset: {self.avg_eval_losses[-1]:.4f}\")\n",
    "\n",
    "    def plot(self):\n",
    "        plt.plot(self.avg_train_losses, label='train')\n",
    "        plt.plot(self.avg_eval_losses, label='test')\n",
    "        plt.xlabel('epoch')\n",
    "        plt.ylabel('loss')\n",
    "        plt.legend()\n",
    "        plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.2 Train the model\n",
    "\n",
    "The [./revlog_history.tsv](./revlog_history.tsv) generated before will be used for training the FSRS model."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "a0f07c46b6d741f19d72e6533c301d8e",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/25136 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Tensorized!\n",
      "dataset built\n",
      "Loss in trainset: 0.3887\n",
      "Loss in testset: 0.3887\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "33f1fac4beb741c79ade5cfe4a70a161",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "pre-train:   0%|          | 0/280400 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "w: [0.0, 1.0, 5.0, 0.5, 0.5, 0.2, 1.4, 0.12, 0.8, 2.0, 0.2, 0.2, 1.0, 3.1498, -1.4292, -0.2497, 4.3865]\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "e3dbe1e433534ca3a287466e9b4042fb",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "train:   0%|          | 0/97640 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss in trainset: 0.3429\n",
      "Loss in testset: 0.3429\n",
      "iteration: 9728\n",
      "w: [0.0, 1.0, 4.9935, 2.2957, 1.7524, 0.0, 1.8641, 0.1961, 1.3147, 2.0761, 0.2258, 0.582, 1.6709, 3.1792, -1.4485, -0.2718, 4.3978]\n",
      "iteration: 19456\n",
      "w: [0.0, 1.0, 4.9546, 2.7362, 2.0421, 0.0324, 1.9016, 0.2147, 1.3257, 1.9436, 0.4396, 0.8777, 1.7627, 3.1832, -1.4511, -0.2747, 4.3993]\n",
      "Loss in trainset: 0.3166\n",
      "Loss in testset: 0.3166\n",
      "iteration: 28744\n",
      "w: [0.0, 1.0, 4.791, 2.8015, 2.1566, 0.0, 1.8996, 0.2206, 1.2698, 2.0938, 0.332, 0.7547, 2.0782, 3.1836, -1.4514, -0.2751, 4.3995]\n",
      "iteration: 38472\n",
      "w: [0.0, 1.0, 4.5595, 2.7283, 2.2232, 0.0, 1.9639, 0.2521, 1.3437, 2.085, 0.3755, 0.6564, 2.2501, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "Loss in trainset: 0.3161\n",
      "Loss in testset: 0.3161\n",
      "iteration: 47760\n",
      "w: [0.0, 1.0, 4.613, 2.8274, 2.3719, 0.0, 1.8692, 0.1093, 1.2289, 1.9719, 0.5036, 0.7027, 2.2279, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "iteration: 57488\n",
      "w: [0.0, 1.0, 4.4831, 2.7726, 2.4051, 0.0014, 1.8587, 0.2484, 1.2064, 1.9535, 0.5276, 0.7599, 2.2518, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "Loss in trainset: 0.3160\n",
      "Loss in testset: 0.3160\n",
      "iteration: 66776\n",
      "w: [0.0, 1.0, 4.3429, 2.6652, 2.3922, 0.0304, 1.9061, 0.2542, 1.2455, 1.9775, 0.5054, 0.7536, 2.2829, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "iteration: 76504\n",
      "w: [0.0, 1.0, 4.3238, 2.6761, 2.4127, 0.0011, 1.9219, 0.2425, 1.2533, 1.9562, 0.5277, 0.7531, 2.2571, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "Loss in trainset: 0.3152\n",
      "Loss in testset: 0.3152\n",
      "iteration: 85792\n",
      "w: [0.0, 1.0, 4.3186, 2.6917, 2.4196, 0.0058, 1.9293, 0.2255, 1.2575, 1.9705, 0.5132, 0.7624, 2.2772, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "iteration: 95520\n",
      "w: [0.0, 1.0, 4.3182, 2.6959, 2.4214, 0.0054, 1.9293, 0.223, 1.2568, 1.9725, 0.5112, 0.7619, 2.2805, 3.1837, -1.4515, -0.2752, 4.3995]\n",
      "Loss in trainset: 0.3151\n",
      "Loss in testset: 0.3151\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Training finished!\n"
     ]
    }
   ],
   "source": [
    "dataset = pd.read_csv(\"./revlog_history.tsv\", sep='\\t', index_col=None, dtype={'r_history': str ,'t_history': str} )\n",
    "dataset = dataset[(dataset['i'] > 1) & (dataset['delta_t'] > 0) & (dataset['t_history'].str.count(',0') == 0)]\n",
    "dataset['tensor'] = dataset.progress_apply(lambda x: lineToTensor(list(zip([x['t_history']], [x['r_history']]))[0]), axis=1)\n",
    "dataset['y'] = dataset['r'].map({1: 0, 2: 1, 3: 1, 4: 1})\n",
    "dataset['group'] = dataset['r_history'] + dataset['t_history']\n",
    "print(\"Tensorized!\")\n",
    "\n",
    "from sklearn.model_selection import StratifiedGroupKFold\n",
    "\n",
    "w = []\n",
    "\n",
    "# sgkf = StratifiedGroupKFold(n_splits=5)\n",
    "# for train_index, test_index in sgkf.split(dataset, dataset['i'], dataset['group']):\n",
    "#     print(\"TRAIN:\", len(train_index), \"TEST:\",  len(test_index))\n",
    "#     train_set = dataset.iloc[train_index].copy()\n",
    "#     test_set = dataset.iloc[test_index].copy()\n",
    "#     optimizer = Optimizer(train_set, test_set, n_epoch=5, lr=4e-2, batch_size=512)\n",
    "#     w.append(optimizer.train())\n",
    "#     optimizer.plot()\n",
    "\n",
    "optimizer = Optimizer(dataset, dataset, n_epoch=5, lr=4e-2, batch_size=512)\n",
    "w.append(optimizer.train())\n",
    "optimizer.plot()\n",
    "\n",
    "print(\"\\nTraining finished!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.3 Result\n",
    "\n",
    "Copy the optimal parameters for FSRS for you in the output of next code cell after running."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.0, 1.0, 4.3182, 2.6959, 2.4214, 0.0053, 1.9293, 0.223, 1.2568, 1.9725, 0.5112, 0.7619, 2.2805, 3.1837, -1.4515, -0.2752, 4.3995]\n"
     ]
    }
   ],
   "source": [
    "w = np.array(w)\n",
    "avg_w = np.round(np.mean(w, axis=0), 4)\n",
    "print(avg_w.tolist())"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.4 Preview\n",
    "\n",
    "You can see the memory states and intervals generated by FSRS as if you press the good in each review at the due date scheduled by FSRS."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1:again, 2:hard, 3:good, 4:easy\n",
      "\n",
      "first rating: 1\n",
      "rating history: 1,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,24,38,59,89,132,190,270,376,516,698\n",
      "difficulty history: 0,9.7,9.7,9.7,9.6,9.6,9.6,9.5,9.5,9.5,9.5\n",
      "\n",
      "first rating: 2\n",
      "rating history: 2,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,1,5,18,53,135,304,623,1181,2103,3550\n",
      "difficulty history: 0,7.0,7.0,7.0,7.0,7.0,6.9,6.9,6.9,6.9,6.9\n",
      "\n",
      "first rating: 3\n",
      "rating history: 3,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,1,7,35,133,408,1066,2453,5104,9789,17559\n",
      "difficulty history: 0,4.3,4.3,4.3,4.3,4.3,4.3,4.3,4.3,4.3,4.3\n",
      "\n",
      "first rating: 4\n",
      "rating history: 4,3,3,3,3,3,3,3,3,3,3\n",
      "interval history: 0,81,344,1150,3206,7759,16794,33231,61123,105841,174249\n",
      "difficulty history: 0,1.6,1.6,1.7,1.7,1.7,1.7,1.7,1.7,1.7,1.7\n",
      "\n"
     ]
    }
   ],
   "source": [
    "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
    "\n",
    "\n",
    "class Collection:\n",
    "    def __init__(self, w):\n",
    "        self.model = FSRS(w)\n",
    "        self.model.eval()\n",
    "\n",
    "    def predict(self, t_history, r_history):\n",
    "        with torch.no_grad():\n",
    "            line_tensor = lineToTensor(list(zip([t_history], [r_history]))[0]).unsqueeze(1)\n",
    "            output_t = self.model(line_tensor)\n",
    "            return output_t[-1][0]\n",
    "        \n",
    "    def batch_predict(self, dataset):\n",
    "        fast_dataset = RevlogDataset(dataset)\n",
    "        outputs, _ = self.model(fast_dataset.x_train.transpose(0, 1))\n",
    "        stabilities, difficulties = outputs[fast_dataset.seq_len-1, torch.arange(len(fast_dataset))].transpose(0, 1)\n",
    "        return stabilities.tolist(), difficulties.tolist()\n",
    "\n",
    "my_collection = Collection(avg_w)\n",
    "print(\"1:again, 2:hard, 3:good, 4:easy\\n\")\n",
    "for first_rating in (1,2,3,4):\n",
    "    print(f'first rating: {first_rating}')\n",
    "    t_history = \"0\"\n",
    "    d_history = \"0\"\n",
    "    r_history = f\"{first_rating}\"  # the first rating of the new card\n",
    "    # print(\"stability, difficulty, lapses\")\n",
    "    for i in range(10):\n",
    "        states = my_collection.predict(t_history, r_history)\n",
    "        # print('{0:9.2f} {1:11.2f} {2:7.0f}'.format(\n",
    "            # *list(map(lambda x: round(float(x), 4), states))))\n",
    "        next_t = max(round(float(np.log(requestRetention)/np.log(0.9) * states[0])), 1)\n",
    "        difficulty = round(float(states[1]), 1)\n",
    "        t_history += f',{int(next_t)}'\n",
    "        d_history += f',{difficulty}'\n",
    "        r_history += f\",3\"\n",
    "    print(f\"rating history: {r_history}\")\n",
    "    print(f\"interval history: {t_history}\")\n",
    "    print(f\"difficulty history: {d_history}\")\n",
    "    print('')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can change the `test_rating_sequence` to see the scheduling intervals in different ratings."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor([0.7594, 4.3182])\n",
      "tensor([7.3274, 4.3182])\n",
      "tensor([34.9750,  4.3182])\n",
      "tensor([132.5714,   4.3182])\n",
      "tensor([408.1076,   4.3182])\n",
      "tensor([77.9938,  9.1353])\n",
      "tensor([21.1070, 10.0000])\n",
      "tensor([31.2103,  9.9699])\n",
      "tensor([45.2762,  9.9399])\n",
      "tensor([64.5972,  9.9101])\n",
      "tensor([91.0829,  9.8805])\n",
      "tensor([126.3300,   9.8510])\n",
      "rating history: 3,3,3,3,3,1,1,3,3,3,3,3\n",
      "interval history: 0,1,7,35,133,408,78,21,31,45,65,91,126\n",
      "difficulty history: 0,4.3,4.3,4.3,4.3,4.3,9.1,10.0,10.0,9.9,9.9,9.9,9.9\n"
     ]
    }
   ],
   "source": [
    "test_rating_sequence = \"3,3,3,3,3,1,1,3,3,3,3,3\"\n",
    "requestRetention = 0.9  # recommended setting: 0.8 ~ 0.9\n",
    "easyBonus = 1.3\n",
    "hardInterval = 1.2\n",
    "\n",
    "t_history = \"0\"\n",
    "d_history = \"0\"\n",
    "for i in range(len(test_rating_sequence.split(','))):\n",
    "    rating = test_rating_sequence[2*i]\n",
    "    last_t = int(t_history.split(',')[-1])\n",
    "    r_history = test_rating_sequence[:2*i+1]\n",
    "    states = my_collection.predict(t_history, r_history)\n",
    "    print(states)\n",
    "    next_t = max(1,round(float(np.log(requestRetention)/np.log(0.9) * states[0])))\n",
    "    if rating == '4':\n",
    "        next_t = round(next_t * easyBonus)\n",
    "    elif rating == '2':\n",
    "        next_t = round(last_t * hardInterval)\n",
    "    t_history += f',{int(next_t)}'\n",
    "    difficulty = round(float(states[1]), 1)\n",
    "    d_history += f',{difficulty}'\n",
    "print(f\"rating history: {test_rating_sequence}\")\n",
    "print(f\"interval history: {t_history}\")\n",
    "print(f\"difficulty history: {d_history}\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 2.5 Predict memory states and distribution of difficulty\n",
    "\n",
    "Predict memory states for each review group and save them in [./prediction.tsv](./prediction.tsv).\n",
    "\n",
    "Meanwhile, it will count the distribution of difficulty."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "prediction.tsv saved.\n",
      "difficulty\n",
      "1     0.016988\n",
      "2     0.084659\n",
      "3     0.001353\n",
      "4     0.264959\n",
      "5     0.000159\n",
      "6     0.010742\n",
      "7     0.145409\n",
      "8     0.002506\n",
      "9     0.109087\n",
      "10    0.364139\n",
      "Name: count, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "stabilities = map(lambda x: round(x, 2), stabilities)\n",
    "difficulties = map(lambda x: round(x, 2), difficulties)\n",
    "dataset['stability'] = list(stabilities)\n",
    "dataset['difficulty'] = list(difficulties)\n",
    "prediction = dataset.groupby(by=['t_history', 'r_history']).agg({\"stability\": \"mean\", \"difficulty\": \"mean\", \"id\": \"count\"})\n",
    "prediction.reset_index(inplace=True)\n",
    "prediction.sort_values(by=['r_history'], inplace=True)\n",
    "prediction.rename(columns={\"id\": \"count\"}, inplace=True)\n",
    "prediction.to_csv(\"./prediction.tsv\", sep='\\t', index=None)\n",
    "print(\"prediction.tsv saved.\")\n",
    "prediction['difficulty'] = prediction['difficulty'].map(lambda x: int(round(x)))\n",
    "difficulty_distribution = prediction.groupby(by=['difficulty'])['count'].sum() / prediction['count'].sum()\n",
    "print(difficulty_distribution)\n",
    "difficulty_distribution_padding = np.zeros(10)\n",
    "for i in range(10):\n",
    "    if i+1 in difficulty_distribution.index:\n",
    "        difficulty_distribution_padding[i] = difficulty_distribution.loc[i+1]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3 Optimize retention to minimize the time of reviews\n",
    "\n",
    "Calculate the optimal retention to minimize the time for long-term memory consolidation. It is an experimental feature. You can use the simulator to get more accurate results:\n",
    "\n",
    "https://github.com/open-spaced-repetition/fsrs4anki/blob/main/fsrs4anki_simulator.ipynb"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "average time for failed cards: 22.6s\n",
      "average time for recalled cards: 5.2s\n",
      "terminal stability:  100.18\n"
     ]
    },
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "f493627b848e4932893a541e8bdf0b4b",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "  0%|          | 0/15 [00:00<?, ?it/s]"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "expected_time.csv saved.\n",
      "\n",
      "-----suggested retention (experimental): 0.77-----\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "base = 1.01\n",
    "index_len = 664\n",
    "index_offset = 200\n",
    "d_range = 10\n",
    "d_offset = 1\n",
    "r_time = 8\n",
    "f_time = 25\n",
    "max_time = 200000\n",
    "\n",
    "type_block = dict()\n",
    "type_count = dict()\n",
    "type_time = dict()\n",
    "last_t = type_sequence[0]\n",
    "type_block[last_t] = 1\n",
    "type_count[last_t] = 1\n",
    "type_time[last_t] = time_sequence[0]\n",
    "for i,t in enumerate(type_sequence[1:]):\n",
    "    type_count[t] = type_count.setdefault(t, 0) + 1\n",
    "    type_time[t] = type_time.setdefault(t, 0) + time_sequence[i]\n",
    "    if t != last_t:\n",
    "        type_block[t] = type_block.setdefault(t, 0) + 1\n",
    "    last_t = t\n",
    "\n",
    "r_time = round(type_time[1]/type_count[1]/1000, 1)\n",
    "\n",
    "if 2 in type_count and 2 in type_block:\n",
    "    f_time = round(type_time[2]/type_block[2]/1000 + r_time, 1)\n",
    "\n",
    "print(f\"average time for failed cards: {f_time}s\")\n",
    "print(f\"average time for recalled cards: {r_time}s\")\n",
    "\n",
    "def stability2index(stability):\n",
    "    return int(round(np.log(stability) / np.log(base)) + index_offset)\n",
    "\n",
    "def init_stability(d):\n",
    "    return max(avg_w[12+int((d - avg_w[2]) / -avg_w[3] + 2)] * avg_w[1] + avg_w[0], np.power(base, -index_offset))\n",
    "\n",
    "def cal_next_recall_stability(s, r, d, response):\n",
    "    if response == 1:\n",
    "        return s * (1 + np.exp(avg_w[6]) * (11 - d) * np.power(s, -avg_w[7]) * (np.exp((1 - r) * avg_w[8]) - 1))\n",
    "    else:\n",
    "        return avg_w[9] * np.power(d, -avg_w[10]) * np.power(s, avg_w[11]) * np.exp((1 - r) * avg_w[12])\n",
    "\n",
    "\n",
    "stability_list = np.array([np.power(base, i - index_offset) for i in range(index_len)])\n",
    "print(f\"terminal stability: {stability_list.max(): .2f}\")\n",
    "df = pd.DataFrame(columns=[\"retention\", \"difficulty\", \"time\"])\n",
    "\n",
    "for percentage in notebook.tqdm(range(96, 66, -2)):\n",
    "    recall = percentage / 100\n",
    "    time_list = np.zeros((d_range, index_len))\n",
    "    time_list[:,:-1] = max_time\n",
    "    for d in range(d_range, 0, -1):\n",
    "        s0 = init_stability(d)\n",
    "        s0_index = stability2index(s0)\n",
    "        diff = max_time\n",
    "        while diff > 0.1:\n",
    "            s0_time = time_list[d - 1][s0_index]\n",
    "            for s_index in range(index_len - 2, -1, -1):\n",
    "                stability = stability_list[s_index]\n",
    "                interval = max(1, round(stability * np.log(recall) / np.log(0.9)))\n",
    "                p_recall = np.power(0.9, interval / stability)\n",
    "                recall_s = cal_next_recall_stability(stability, p_recall, d, 1)\n",
    "                forget_d = min(d + d_offset, 10)\n",
    "                forget_s = cal_next_recall_stability(stability, p_recall, forget_d, 0)\n",
    "                recall_s_index = min(stability2index(recall_s), index_len - 1)\n",
    "                forget_s_index = min(max(stability2index(forget_s), 0), index_len - 1)\n",
    "                recall_time = time_list[d - 1][recall_s_index] + r_time\n",
    "                forget_time = time_list[forget_d - 1][forget_s_index] + f_time\n",
    "                exp_time = p_recall * recall_time + (1.0 - p_recall) * forget_time\n",
    "                if exp_time < time_list[d - 1][s_index]:\n",
    "                    time_list[d - 1][s_index] = exp_time\n",
    "            diff = s0_time - time_list[d - 1][s0_index]\n",
    "        df.loc[0 if pd.isnull(df.index.max()) else df.index.max() + 1] = [recall, d, s0_time]\n",
    "\n",
    "df.sort_values(by=[\"difficulty\", \"retention\"], inplace=True)\n",
    "df.to_csv(\"./expected_time.csv\", index=False)\n",
    "print(\"expected_time.csv saved.\")\n",
    "\n",
    "optimal_retention_list = np.zeros(10)\n",
    "for d in range(1, d_range+1):\n",
    "    retention = df[df[\"difficulty\"] == d][\"retention\"]\n",
    "    time = df[df[\"difficulty\"] == d][\"time\"]\n",
    "    optimal_retention = retention.iat[time.argmin()]\n",
    "    optimal_retention_list[d-1] = optimal_retention\n",
    "    plt.plot(retention, time, label=f\"d={d}, r={optimal_retention}\")\n",
    "print(f\"\\n-----suggested retention (experimental): {np.inner(difficulty_distribution_padding, optimal_retention_list):.2f}-----\")\n",
    "plt.ylabel(\"expected time (second)\")\n",
    "plt.xlabel(\"retention\")\n",
    "plt.legend()\n",
    "plt.grid()\n",
    "plt.semilogy()\n",
    "plt.show()"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4 Evaluate the model"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.1 Loss\n",
    "\n",
    "Evaluate the model with the log loss. It will compare the log loss between initial model and trained model.\n",
    "\n",
    "And it will predict the stability, difficulty and retrievability for each revlog in [./evaluation.tsv](./evaluation.tsv)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Loss before training: 0.3887\n",
      "Loss after training: 0.3151\n"
     ]
    }
   ],
   "source": [
    "my_collection = Collection(init_w)\n",
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "dataset['stability'] = stabilities\n",
    "dataset['difficulty'] = difficulties\n",
    "dataset['p'] = np.exp(np.log(0.9) * dataset['delta_t'] / dataset['stability'])\n",
    "dataset['log_loss'] = dataset.apply(lambda row: - np.log(row['p']) if row['y'] == 1 else - np.log(1 - row['p']), axis=1)\n",
    "print(f\"Loss before training: {dataset['log_loss'].mean():.4f}\")\n",
    "\n",
    "my_collection = Collection(avg_w)\n",
    "stabilities, difficulties = my_collection.batch_predict(dataset)\n",
    "dataset['stability'] = stabilities\n",
    "dataset['difficulty'] = difficulties\n",
    "dataset['p'] = np.exp(np.log(0.9) * dataset['delta_t'] / dataset['stability'])\n",
    "dataset['log_loss'] = dataset.apply(lambda row: - np.log(row['p']) if row['y'] == 1 else - np.log(1 - row['p']), axis=1)\n",
    "print(f\"Loss after training: {dataset['log_loss'].mean():.4f}\")\n",
    "\n",
    "tmp = dataset.copy()\n",
    "tmp['stability'] = tmp['stability'].map(lambda x: round(x, 2))\n",
    "tmp['difficulty'] = tmp['difficulty'].map(lambda x: round(x, 2))\n",
    "tmp['p'] = tmp['p'].map(lambda x: round(x, 2))\n",
    "tmp['log_loss'] = tmp['log_loss'].map(lambda x: round(x, 2))\n",
    "tmp.rename(columns={\"r\": \"grade\", \"p\": \"retrievability\"}, inplace=True)\n",
    "tmp[['id', 'cid', 'review_date', 'r_history', 't_history', 'delta_t', 'grade', 'stability', 'difficulty', 'retrievability', 'log_loss']].to_csv(\"./evaluation.tsv\", sep='\\t', index=False)\n",
    "del tmp"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 4.2 Calibration graph\n",
    "\n",
    "1. FSRS predicts the stability and retention for each review.\n",
    "2. Reviews are grouped into 40 bins according to their predicted retention.\n",
    "3. Count the true retention of each bin.\n",
    "4. Plot (predicted retention, true retention) in the line graph.\n",
    "5. Plot (predicted retention, size of bin) in the bar graph.\n",
    "6. Combine these graphs to create the calibration graph.\n",
    "\n",
    "Ideally, the blue line should be aligned with the orange one. If the blue line is higher than the orange line, the FSRS underestimates the retention. When the size of reviews within a bin is small, actual retention may deviate largely, which is normal.\n",
    "\n",
    "R-squared (aka the coefficient of determination), is the proportion of the variation in the dependent variable that is predictable from the independent variable(s). The higher the R-squared, the better the model fits your data. For details, please see https://en.wikipedia.org/wiki/Coefficient_of_determination\n",
    "\n",
    "RMSE (root mean squared error) is the square root of the average of squared differences between prediction and actual observation. The lower the RMSE, the better the model fits your data. For details, please see https://en.wikipedia.org/wiki/Root-mean-square_deviation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "R-squared: 0.9447\n",
      "RMSE: 0.0270\n",
      "[0.04625006 0.9458979 ]\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import mean_squared_error, r2_score\n",
    "import statsmodels.api as sm\n",
    "\n",
    "\n",
    "# code from https://github.com/papousek/duolingo-halflife-regression/blob/master/evaluation.py\n",
    "def load_brier(predictions, real, bins=20):\n",
    "    counts = np.zeros(bins)\n",
    "    correct = np.zeros(bins)\n",
    "    prediction = np.zeros(bins)\n",
    "    for p, r in zip(predictions, real):\n",
    "        bin = min(int(p * bins), bins - 1)\n",
    "        counts[bin] += 1\n",
    "        correct[bin] += r\n",
    "        prediction[bin] += p\n",
    "    np.seterr(invalid='ignore')\n",
    "    prediction_means = prediction / counts\n",
    "    prediction_means[np.isnan(prediction_means)] = ((np.arange(bins) + 0.5) / bins)[np.isnan(prediction_means)]\n",
    "    correct_means = correct / counts\n",
    "    correct_means[np.isnan(correct_means)] = 0\n",
    "    size = len(predictions)\n",
    "    answer_mean = sum(correct) / size\n",
    "    return {\n",
    "        \"reliability\": sum(counts * (correct_means - prediction_means) ** 2) / size,\n",
    "        \"resolution\": sum(counts * (correct_means - answer_mean) ** 2) / size,\n",
    "        \"uncertainty\": answer_mean * (1 - answer_mean),\n",
    "        \"detail\": {\n",
    "            \"bin_count\": bins,\n",
    "            \"bin_counts\": list(counts),\n",
    "            \"bin_prediction_means\": list(prediction_means),\n",
    "            \"bin_correct_means\": list(correct_means),\n",
    "        }\n",
    "    }\n",
    "\n",
    "\n",
    "def plot_brier(predictions, real, bins=20):\n",
    "    brier = load_brier(predictions, real, bins=bins)\n",
    "    bin_prediction_means = brier['detail']['bin_prediction_means']\n",
    "    bin_correct_means = brier['detail']['bin_correct_means']\n",
    "    bin_counts = brier['detail']['bin_counts']\n",
    "    r2 = r2_score(bin_correct_means, bin_prediction_means, sample_weight=bin_counts)\n",
    "    rmse = np.sqrt(mean_squared_error(bin_correct_means, bin_prediction_means, sample_weight=bin_counts))\n",
    "    print(f\"R-squared: {r2:.4f}\")\n",
    "    print(f\"RMSE: {rmse:.4f}\")\n",
    "    plt.figure()\n",
    "    ax = plt.gca()\n",
    "    ax.set_xlim([0, 1])\n",
    "    ax.set_ylim([0, 1])\n",
    "    plt.grid(True)\n",
    "    fit_wls = sm.WLS(bin_correct_means, sm.add_constant(bin_prediction_means), weights=bin_counts).fit()\n",
    "    print(fit_wls.params)\n",
    "    y_regression = [fit_wls.params[0] + fit_wls.params[1]*x for x in bin_prediction_means]\n",
    "    plt.plot(bin_prediction_means, y_regression, label='Weighted Least Squares Regression', color=\"green\")\n",
    "    plt.plot(bin_prediction_means, bin_correct_means, label='Actual Calibration', color=\"#1f77b4\")\n",
    "    plt.plot((0, 1), (0, 1), label='Perfect Calibration', color=\"#ff7f0e\")\n",
    "    bin_count = brier['detail']['bin_count']\n",
    "    counts = np.array(bin_counts)\n",
    "    bins = (np.arange(bin_count) + 0.5) / bin_count\n",
    "    plt.legend(loc='upper center')\n",
    "    plt.xlabel('Predicted R')\n",
    "    plt.ylabel('Actual R')\n",
    "    plt.twinx()\n",
    "    plt.ylabel('Number of reviews')\n",
    "    plt.bar(bins, counts, width=(0.8 / bin_count), ec='k', lw=.2, alpha=0.5, label='Number of reviews')\n",
    "    plt.legend(loc='lower center')\n",
    "\n",
    "\n",
    "plot_brier(dataset['p'], dataset['y'], bins=40)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.ticker as ticker\n",
    "\n",
    "def to_percent(temp, position):\n",
    "    return '%1.0f' % (100 * temp) + '%'\n",
    "\n",
    "fig = plt.figure(1)\n",
    "ax1 = fig.add_subplot(111)\n",
    "ax2 = ax1.twinx()\n",
    "lns = []\n",
    "\n",
    "stability_calibration = pd.DataFrame(columns=['stability', 'predicted_retention', 'actual_retention'])\n",
    "stability_calibration = dataset[['stability', 'p', 'y']].copy()\n",
    "stability_calibration['bin'] = stability_calibration['stability'].map(lambda x: math.pow(1.2, math.floor(math.log(x, 1.2))))\n",
    "stability_group = stability_calibration.groupby('bin').count()\n",
    "\n",
    "lns1 = ax1.bar(x=stability_group.index, height=stability_group['y'], width=stability_group.index / 5.5,\n",
    "                ec='k', lw=.2, label='Number of predictions', alpha=0.5)\n",
    "ax1.set_ylabel(\"Number of predictions\")\n",
    "ax1.set_xlabel(\"Stability (days)\")\n",
    "ax1.semilogx()\n",
    "lns.append(lns1)\n",
    "\n",
    "stability_group = stability_calibration.groupby(by='bin').agg('mean')\n",
    "lns2 = ax2.plot(stability_group['y'], label='Actual retention')\n",
    "lns3 = ax2.plot(stability_group['p'], label='Predicted retention')\n",
    "ax2.set_ylabel(\"Retention\")\n",
    "ax2.set_ylim(0, 1)\n",
    "lns.append(lns2[0])\n",
    "lns.append(lns3[0])\n",
    "\n",
    "labs = [l.get_label() for l in lns]\n",
    "ax2.legend(lns, labs, loc='lower right')\n",
    "plt.grid(linestyle='--')\n",
    "plt.gca().yaxis.set_major_formatter(ticker.FuncFormatter(to_percent))\n",
    "plt.gca().xaxis.set_major_formatter(ticker.FormatStrFormatter('%d'))\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<style type=\"text/css\">\n",
       "#T_c3ae6_row0_col0, #T_c3ae6_row0_col1, #T_c3ae6_row0_col2, #T_c3ae6_row0_col4, #T_c3ae6_row0_col5, #T_c3ae6_row1_col0, #T_c3ae6_row1_col1, #T_c3ae6_row1_col2, #T_c3ae6_row1_col3, #T_c3ae6_row1_col4, #T_c3ae6_row2_col0, #T_c3ae6_row2_col1, #T_c3ae6_row2_col2, #T_c3ae6_row2_col3, #T_c3ae6_row3_col0, #T_c3ae6_row3_col1, #T_c3ae6_row3_col3, #T_c3ae6_row4_col0, #T_c3ae6_row4_col1, #T_c3ae6_row4_col2, #T_c3ae6_row4_col3, #T_c3ae6_row4_col4, #T_c3ae6_row5_col0, #T_c3ae6_row5_col1, #T_c3ae6_row5_col2, #T_c3ae6_row5_col3, #T_c3ae6_row5_col4, #T_c3ae6_row6_col0, #T_c3ae6_row6_col1, #T_c3ae6_row6_col2, #T_c3ae6_row6_col3, #T_c3ae6_row7_col0, #T_c3ae6_row7_col1, #T_c3ae6_row7_col2, #T_c3ae6_row7_col3, #T_c3ae6_row8_col0, #T_c3ae6_row8_col1, #T_c3ae6_row8_col2, #T_c3ae6_row9_col0, #T_c3ae6_row9_col1, #T_c3ae6_row9_col3, #T_c3ae6_row10_col0, #T_c3ae6_row10_col1, #T_c3ae6_row10_col2, #T_c3ae6_row11_col0, #T_c3ae6_row11_col1, #T_c3ae6_row12_col0, #T_c3ae6_row12_col1, #T_c3ae6_row13_col0, #T_c3ae6_row13_col1, #T_c3ae6_row14_col0, #T_c3ae6_row14_col1, #T_c3ae6_row15_col0, #T_c3ae6_row15_col1, #T_c3ae6_row16_col0, #T_c3ae6_row16_col1, #T_c3ae6_row17_col0, #T_c3ae6_row18_col3, #T_c3ae6_row18_col4, #T_c3ae6_row19_col4, #T_c3ae6_row20_col0, #T_c3ae6_row20_col1, #T_c3ae6_row20_col3, #T_c3ae6_row20_col4, #T_c3ae6_row20_col5 {\n",
       "  background-color: #000000;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row0_col3 {\n",
       "  background-color: #ffd9d9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row1_col5, #T_c3ae6_row9_col2 {\n",
       "  background-color: #a5a5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row2_col4, #T_c3ae6_row5_col5, #T_c3ae6_row16_col5 {\n",
       "  background-color: #d9d9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row2_col5 {\n",
       "  background-color: #ff7979;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row3_col2, #T_c3ae6_row12_col3 {\n",
       "  background-color: #fff5f5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row3_col4, #T_c3ae6_row9_col4, #T_c3ae6_row10_col4, #T_c3ae6_row19_col2, #T_c3ae6_row20_col2 {\n",
       "  background-color: #fff1f1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row3_col5 {\n",
       "  background-color: #ff7171;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row4_col5 {\n",
       "  background-color: #ff9999;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row6_col4 {\n",
       "  background-color: #ffe1e1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row6_col5, #T_c3ae6_row9_col5, #T_c3ae6_row16_col2 {\n",
       "  background-color: #e9e9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row7_col4, #T_c3ae6_row16_col4, #T_c3ae6_row17_col3 {\n",
       "  background-color: #fff9f9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row7_col5, #T_c3ae6_row12_col4 {\n",
       "  background-color: #fffdfd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row8_col3, #T_c3ae6_row11_col5, #T_c3ae6_row15_col5 {\n",
       "  background-color: #ffb9b9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row8_col4, #T_c3ae6_row18_col1 {\n",
       "  background-color: #adadff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row8_col5 {\n",
       "  background-color: #d5d5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row10_col3, #T_c3ae6_row12_col2 {\n",
       "  background-color: #ddddff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row10_col5 {\n",
       "  background-color: #ffc5c5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row11_col2 {\n",
       "  background-color: #f1f1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row11_col3, #T_c3ae6_row19_col3 {\n",
       "  background-color: #e5e5ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row11_col4 {\n",
       "  background-color: #ff4d4d;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row12_col5 {\n",
       "  background-color: #ffc1c1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row13_col2 {\n",
       "  background-color: #9191ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row13_col3 {\n",
       "  background-color: #ff7575;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row13_col4, #T_c3ae6_row14_col3, #T_c3ae6_row18_col2 {\n",
       "  background-color: #ffe5e5;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row13_col5 {\n",
       "  background-color: #ffa1a1;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row14_col2, #T_c3ae6_row19_col5 {\n",
       "  background-color: #d1d1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row14_col4 {\n",
       "  background-color: #ff4949;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row14_col5 {\n",
       "  background-color: #ffe9e9;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row15_col2 {\n",
       "  background-color: #cdcdff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row15_col3 {\n",
       "  background-color: #ffcdcd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row15_col4 {\n",
       "  background-color: #ffeded;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row16_col3 {\n",
       "  background-color: #b1b1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row17_col1 {\n",
       "  background-color: #f9f9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row17_col2 {\n",
       "  background-color: #c9c9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row17_col4 {\n",
       "  background-color: #ffdddd;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row17_col5 {\n",
       "  background-color: #e1e1ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row18_col0 {\n",
       "  background-color: #7575ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row18_col5 {\n",
       "  background-color: #b9b9ff;\n",
       "  color: #000000;\n",
       "}\n",
       "#T_c3ae6_row19_col0 {\n",
       "  background-color: #3535ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "#T_c3ae6_row19_col1 {\n",
       "  background-color: #6969ff;\n",
       "  color: #f1f1f1;\n",
       "}\n",
       "</style>\n",
       "<table id=\"T_c3ae6\">\n",
       "  <thead>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >d_bin</th>\n",
       "      <th id=\"T_c3ae6_level0_col0\" class=\"col_heading level0 col0\" >1</th>\n",
       "      <th id=\"T_c3ae6_level0_col1\" class=\"col_heading level0 col1\" >2</th>\n",
       "      <th id=\"T_c3ae6_level0_col2\" class=\"col_heading level0 col2\" >4</th>\n",
       "      <th id=\"T_c3ae6_level0_col3\" class=\"col_heading level0 col3\" >7</th>\n",
       "      <th id=\"T_c3ae6_level0_col4\" class=\"col_heading level0 col4\" >9</th>\n",
       "      <th id=\"T_c3ae6_level0_col5\" class=\"col_heading level0 col5\" >10</th>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th class=\"index_name level0\" >s_bin</th>\n",
       "      <th class=\"blank col0\" >&nbsp;</th>\n",
       "      <th class=\"blank col1\" >&nbsp;</th>\n",
       "      <th class=\"blank col2\" >&nbsp;</th>\n",
       "      <th class=\"blank col3\" >&nbsp;</th>\n",
       "      <th class=\"blank col4\" >&nbsp;</th>\n",
       "      <th class=\"blank col5\" >&nbsp;</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row0\" class=\"row_heading level0 row0\" >0.190000</th>\n",
       "      <td id=\"T_c3ae6_row0_col0\" class=\"data row0 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row0_col1\" class=\"data row0 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row0_col2\" class=\"data row0 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row0_col3\" class=\"data row0 col3\" >1.48%</td>\n",
       "      <td id=\"T_c3ae6_row0_col4\" class=\"data row0 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row0_col5\" class=\"data row0 col5\" ></td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row1\" class=\"row_heading level0 row1\" >0.360000</th>\n",
       "      <td id=\"T_c3ae6_row1_col0\" class=\"data row1 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row1_col1\" class=\"data row1 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row1_col2\" class=\"data row1 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row1_col3\" class=\"data row1 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row1_col4\" class=\"data row1 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row1_col5\" class=\"data row1 col5\" >-3.44%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row2\" class=\"row_heading level0 row2\" >0.510000</th>\n",
       "      <td id=\"T_c3ae6_row2_col0\" class=\"data row2 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row2_col1\" class=\"data row2 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row2_col2\" class=\"data row2 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row2_col3\" class=\"data row2 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row2_col4\" class=\"data row2 col4\" >-1.45%</td>\n",
       "      <td id=\"T_c3ae6_row2_col5\" class=\"data row2 col5\" >5.19%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row3\" class=\"row_heading level0 row3\" >0.710000</th>\n",
       "      <td id=\"T_c3ae6_row3_col0\" class=\"data row3 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row3_col1\" class=\"data row3 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row3_col2\" class=\"data row3 col2\" >0.34%</td>\n",
       "      <td id=\"T_c3ae6_row3_col3\" class=\"data row3 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row3_col4\" class=\"data row3 col4\" >0.56%</td>\n",
       "      <td id=\"T_c3ae6_row3_col5\" class=\"data row3 col5\" >5.51%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row4\" class=\"row_heading level0 row4\" >1.000000</th>\n",
       "      <td id=\"T_c3ae6_row4_col0\" class=\"data row4 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row4_col1\" class=\"data row4 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row4_col2\" class=\"data row4 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row4_col3\" class=\"data row4 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row4_col4\" class=\"data row4 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row4_col5\" class=\"data row4 col5\" >4.03%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row5\" class=\"row_heading level0 row5\" >1.400000</th>\n",
       "      <td id=\"T_c3ae6_row5_col0\" class=\"data row5 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row5_col1\" class=\"data row5 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row5_col2\" class=\"data row5 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row5_col3\" class=\"data row5 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row5_col4\" class=\"data row5 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row5_col5\" class=\"data row5 col5\" >-1.53%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row6\" class=\"row_heading level0 row6\" >1.960000</th>\n",
       "      <td id=\"T_c3ae6_row6_col0\" class=\"data row6 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row6_col1\" class=\"data row6 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row6_col2\" class=\"data row6 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row6_col3\" class=\"data row6 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row6_col4\" class=\"data row6 col4\" >1.20%</td>\n",
       "      <td id=\"T_c3ae6_row6_col5\" class=\"data row6 col5\" >-0.81%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row7\" class=\"row_heading level0 row7\" >2.740000</th>\n",
       "      <td id=\"T_c3ae6_row7_col0\" class=\"data row7 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row7_col1\" class=\"data row7 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row7_col2\" class=\"data row7 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row7_col3\" class=\"data row7 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row7_col4\" class=\"data row7 col4\" >0.19%</td>\n",
       "      <td id=\"T_c3ae6_row7_col5\" class=\"data row7 col5\" >0.12%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row8\" class=\"row_heading level0 row8\" >3.840000</th>\n",
       "      <td id=\"T_c3ae6_row8_col0\" class=\"data row8 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row8_col1\" class=\"data row8 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row8_col2\" class=\"data row8 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row8_col3\" class=\"data row8 col3\" >2.73%</td>\n",
       "      <td id=\"T_c3ae6_row8_col4\" class=\"data row8 col4\" >-3.22%</td>\n",
       "      <td id=\"T_c3ae6_row8_col5\" class=\"data row8 col5\" >-1.66%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row9\" class=\"row_heading level0 row9\" >5.380000</th>\n",
       "      <td id=\"T_c3ae6_row9_col0\" class=\"data row9 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row9_col1\" class=\"data row9 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row9_col2\" class=\"data row9 col2\" >-3.47%</td>\n",
       "      <td id=\"T_c3ae6_row9_col3\" class=\"data row9 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row9_col4\" class=\"data row9 col4\" >0.54%</td>\n",
       "      <td id=\"T_c3ae6_row9_col5\" class=\"data row9 col5\" >-0.84%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row10\" class=\"row_heading level0 row10\" >7.530000</th>\n",
       "      <td id=\"T_c3ae6_row10_col0\" class=\"data row10 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row10_col1\" class=\"data row10 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row10_col2\" class=\"data row10 col2\" ></td>\n",
       "      <td id=\"T_c3ae6_row10_col3\" class=\"data row10 col3\" >-1.29%</td>\n",
       "      <td id=\"T_c3ae6_row10_col4\" class=\"data row10 col4\" >0.62%</td>\n",
       "      <td id=\"T_c3ae6_row10_col5\" class=\"data row10 col5\" >2.29%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row11\" class=\"row_heading level0 row11\" >10.540000</th>\n",
       "      <td id=\"T_c3ae6_row11_col0\" class=\"data row11 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row11_col1\" class=\"data row11 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row11_col2\" class=\"data row11 col2\" >-0.52%</td>\n",
       "      <td id=\"T_c3ae6_row11_col3\" class=\"data row11 col3\" >-1.05%</td>\n",
       "      <td id=\"T_c3ae6_row11_col4\" class=\"data row11 col4\" >7.03%</td>\n",
       "      <td id=\"T_c3ae6_row11_col5\" class=\"data row11 col5\" >2.66%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row12\" class=\"row_heading level0 row12\" >14.760000</th>\n",
       "      <td id=\"T_c3ae6_row12_col0\" class=\"data row12 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row12_col1\" class=\"data row12 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row12_col2\" class=\"data row12 col2\" >-1.36%</td>\n",
       "      <td id=\"T_c3ae6_row12_col3\" class=\"data row12 col3\" >0.41%</td>\n",
       "      <td id=\"T_c3ae6_row12_col4\" class=\"data row12 col4\" >0.07%</td>\n",
       "      <td id=\"T_c3ae6_row12_col5\" class=\"data row12 col5\" >2.48%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row13\" class=\"row_heading level0 row13\" >20.660000</th>\n",
       "      <td id=\"T_c3ae6_row13_col0\" class=\"data row13 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row13_col1\" class=\"data row13 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row13_col2\" class=\"data row13 col2\" >-4.26%</td>\n",
       "      <td id=\"T_c3ae6_row13_col3\" class=\"data row13 col3\" >5.34%</td>\n",
       "      <td id=\"T_c3ae6_row13_col4\" class=\"data row13 col4\" >1.04%</td>\n",
       "      <td id=\"T_c3ae6_row13_col5\" class=\"data row13 col5\" >3.63%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row14\" class=\"row_heading level0 row14\" >28.930000</th>\n",
       "      <td id=\"T_c3ae6_row14_col0\" class=\"data row14 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row14_col1\" class=\"data row14 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row14_col2\" class=\"data row14 col2\" >-1.73%</td>\n",
       "      <td id=\"T_c3ae6_row14_col3\" class=\"data row14 col3\" >1.01%</td>\n",
       "      <td id=\"T_c3ae6_row14_col4\" class=\"data row14 col4\" >7.06%</td>\n",
       "      <td id=\"T_c3ae6_row14_col5\" class=\"data row14 col5\" >0.79%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row15\" class=\"row_heading level0 row15\" >40.500000</th>\n",
       "      <td id=\"T_c3ae6_row15_col0\" class=\"data row15 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row15_col1\" class=\"data row15 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row15_col2\" class=\"data row15 col2\" >-1.96%</td>\n",
       "      <td id=\"T_c3ae6_row15_col3\" class=\"data row15 col3\" >1.96%</td>\n",
       "      <td id=\"T_c3ae6_row15_col4\" class=\"data row15 col4\" >0.78%</td>\n",
       "      <td id=\"T_c3ae6_row15_col5\" class=\"data row15 col5\" >2.78%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row16\" class=\"row_heading level0 row16\" >56.690000</th>\n",
       "      <td id=\"T_c3ae6_row16_col0\" class=\"data row16 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row16_col1\" class=\"data row16 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row16_col2\" class=\"data row16 col2\" >-0.93%</td>\n",
       "      <td id=\"T_c3ae6_row16_col3\" class=\"data row16 col3\" >-3.02%</td>\n",
       "      <td id=\"T_c3ae6_row16_col4\" class=\"data row16 col4\" >0.28%</td>\n",
       "      <td id=\"T_c3ae6_row16_col5\" class=\"data row16 col5\" >-1.56%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row17\" class=\"row_heading level0 row17\" >79.370000</th>\n",
       "      <td id=\"T_c3ae6_row17_col0\" class=\"data row17 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row17_col1\" class=\"data row17 col1\" >-0.26%</td>\n",
       "      <td id=\"T_c3ae6_row17_col2\" class=\"data row17 col2\" >-2.15%</td>\n",
       "      <td id=\"T_c3ae6_row17_col3\" class=\"data row17 col3\" >0.28%</td>\n",
       "      <td id=\"T_c3ae6_row17_col4\" class=\"data row17 col4\" >1.28%</td>\n",
       "      <td id=\"T_c3ae6_row17_col5\" class=\"data row17 col5\" >-1.18%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row18\" class=\"row_heading level0 row18\" >111.120000</th>\n",
       "      <td id=\"T_c3ae6_row18_col0\" class=\"data row18 col0\" >-5.36%</td>\n",
       "      <td id=\"T_c3ae6_row18_col1\" class=\"data row18 col1\" >-3.14%</td>\n",
       "      <td id=\"T_c3ae6_row18_col2\" class=\"data row18 col2\" >0.98%</td>\n",
       "      <td id=\"T_c3ae6_row18_col3\" class=\"data row18 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row18_col4\" class=\"data row18 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row18_col5\" class=\"data row18 col5\" >-2.77%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row19\" class=\"row_heading level0 row19\" >155.570000</th>\n",
       "      <td id=\"T_c3ae6_row19_col0\" class=\"data row19 col0\" >-7.96%</td>\n",
       "      <td id=\"T_c3ae6_row19_col1\" class=\"data row19 col1\" >-5.88%</td>\n",
       "      <td id=\"T_c3ae6_row19_col2\" class=\"data row19 col2\" >0.59%</td>\n",
       "      <td id=\"T_c3ae6_row19_col3\" class=\"data row19 col3\" >-1.01%</td>\n",
       "      <td id=\"T_c3ae6_row19_col4\" class=\"data row19 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row19_col5\" class=\"data row19 col5\" >-1.72%</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th id=\"T_c3ae6_level0_row20\" class=\"row_heading level0 row20\" >217.800000</th>\n",
       "      <td id=\"T_c3ae6_row20_col0\" class=\"data row20 col0\" ></td>\n",
       "      <td id=\"T_c3ae6_row20_col1\" class=\"data row20 col1\" ></td>\n",
       "      <td id=\"T_c3ae6_row20_col2\" class=\"data row20 col2\" >0.59%</td>\n",
       "      <td id=\"T_c3ae6_row20_col3\" class=\"data row20 col3\" ></td>\n",
       "      <td id=\"T_c3ae6_row20_col4\" class=\"data row20 col4\" ></td>\n",
       "      <td id=\"T_c3ae6_row20_col5\" class=\"data row20 col5\" ></td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n"
      ],
      "text/plain": [
       "<pandas.io.formats.style.Styler at 0x2c1b73a60>"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B_W_Metric_raw = dataset[['difficulty', 'stability', 'p', 'y']].copy()\n",
    "B_W_Metric_raw['s_bin'] = B_W_Metric_raw['stability'].map(lambda x: round(math.pow(1.4, math.floor(math.log(x, 1.4))), 2))\n",
    "B_W_Metric_raw['d_bin'] = B_W_Metric_raw['difficulty'].map(lambda x: int(round(x)))\n",
    "B_W_Metric = B_W_Metric_raw.groupby(by=['s_bin', 'd_bin']).agg('mean').reset_index()\n",
    "B_W_Metric_count = B_W_Metric_raw.groupby(by=['s_bin', 'd_bin']).agg('count').reset_index()\n",
    "B_W_Metric['B-W'] = B_W_Metric['p'] - B_W_Metric['y']\n",
    "n = len(dataset)\n",
    "bins = len(B_W_Metric)\n",
    "B_W_Metric_pivot = B_W_Metric[B_W_Metric_count['p'] > max(50, n / (3 * bins))].pivot(index=\"s_bin\", columns='d_bin', values='B-W')\n",
    "B_W_Metric_pivot.apply(pd.to_numeric).style.background_gradient(cmap='seismic', axis=None, vmin=-0.2, vmax=0.2).format(\"{:.2%}\", na_rep='')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<AxesSubplot: xlabel='d_bin'>"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "B_W_Metric_raw.groupby(by=['d_bin']).agg('count').reset_index().plot.bar(x='d_bin', y='p', legend=False)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "fsrs4anki",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.16"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
